package MoveWindowAndStack;


import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Stack;

//给定一个数组 输出数组中 每个数左边和右边比这个数小 且距离最近的数 如果不存在 输出-1
//使用暴力遍历 时间复杂度为O(n²)   使用单调栈 可以使时间复杂度为O(n)
//依次将数组中的每个位置的下标压入栈中 保证栈从上到下为递减
// 如果新压入的元素值小于栈顶元素（新元素不进栈），则此时新元素为栈顶元素右侧距离最近的最小值 栈顶元素下面的元素为其左侧的最近最小值
//如果数组中有重复值 那么栈中则将数组小标换成一个列表 列表中存储重复值的下标 其余步骤大体不变
public class MinStack {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int length = Integer.parseInt(br.readLine());
        int[] arr = new int[length];
        String[] field = br.readLine().split(" ");
        int term = 0;
        for(int i=0;i<field.length;i++){
            arr[i] = Integer.parseInt(field[i]);
        }
        StringBuffer sb = new StringBuffer();
        for(int j=0;j<length;j++){
            if(j==0){
                term = -1;
            }else {
                for (int a = j - 1; a >= 0; a--) {
                    term = -1;
                    if (arr[j] > arr[a]) {
                        term = a;
                        break;
                    }
                }
            }
            sb.append(term+" ");
            if(j == length-1){
                term = -1;
            }else {
                for (int b = j + 1; b < length; b++) {
                    term = -1;
                    if (arr[j] > arr[b]) {
                        term = b;
                        break;
                    }
                }
            }
            sb.append(term+"\n");
        }
        System.out.print(sb.toString());
        br.close();
    }

    //数组里没有重复值
    public static int[][] getLessNoRepeat(int[] arr){
        Stack<Integer> stack = new Stack<>();
        int[][] arrs= new int[arr.length][2];
        for (int a=0;a<arr.length;a++){
                while (!stack.isEmpty() && arr[a] <= arr[stack.peek()]){
                    int p = stack.pop();
                    arrs[p][1] =  arr[a];             //1代表右边  0代表左边
                    arrs[p][0] = stack.isEmpty()? -1:arr[stack.peek()];
                }
                stack.add(a);
        }
        while (!stack.isEmpty()){
            int p = stack.pop();
            arrs[p][1] =  -1;
            arrs[p][0] = stack.isEmpty()? -1:arr[stack.peek()];
        }
        return arrs;
    }


    public static int getLessRepeat(int[] arr){
    return 0;
    }
}
